home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_gtk+.idb / usr / freeware / info / gtk.info-2.z / gtk.info-2
Encoding:
GNU Info File  |  1999-07-16  |  49.0 KB  |  1,455 lines
  1. This is Info file gtk.info, produced by Makeinfo version 1.68 from the
  2. input file gtk.texi.
  3.  
  4.    This file documents GTK, the GIMP Toolkit
  5.  
  6.    Copyright (C) 1996 Peter Mattis Copyright (C) 1997 Peter Mattis
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided that the
  14. entire resulting derived work is distributed under the terms of a
  15. permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that this permission notice may be stated in a
  20. translation approved by Peter Mattis.
  21.  
  22. INFO-DIR-SECTION User Interface Toolkit
  23. START-INFO-DIR-ENTRY
  24. * GTK: (gtk).        The GIMP Toolkit
  25. END-INFO-DIR-ENTRY
  26.  
  27. 
  28. File: gtk.info,  Node: GtkAlignment,  Next: GtkArrow,  Prev: Widgets,  Up: Widgets
  29.  
  30. The alignment widget
  31. ====================
  32.  
  33. Description
  34. -----------
  35.  
  36.    The alignment widget is a container (*note GtkContainer::.) derived
  37. from the bin widget (*note GtkBin::.). Its entire purpose is to give the
  38. programmer flexibility in how the child it manages is positioned when a
  39. window is resized.
  40.  
  41.    Normally, a widget is allocated at least as much size as it
  42. requests. (*note GtkContainer::. for a discussion of geometry
  43. management). When a widget is allocated more size than it requests there
  44. is a question of how the widget should expand. By convention, most GTK
  45. widgets expand to fill their allocated space. Sometimes this behavior is
  46. not desired. The alignment widget allows the programmer to specify how a
  47. widget should expand and position itself to fill the area it is
  48. allocated.
  49.  
  50. Options
  51. -------
  52.  
  53.  - User Option: xscale
  54.  - User Option: yscale
  55.      The XSCALE and YSCALE options specify how to scale the child
  56.      widget. If the scale value is 0.0, the child widget is allocated
  57.      exactly the size it requested in that dimension. If the scale
  58.      value is 1.0, the child widget is allocated all of the space in a
  59.      dimension. A scale value of 1.0 for both x and y is equivalent to
  60.      not using an alignment widget.
  61.  
  62.  - User Option: xalign
  63.  - User Option: yalign
  64.      The XALIGN and YALIGN options specify how to position the child
  65.      widget when it is not allocated all the space available to it
  66.      (because the XSCALE and/or YSCALE options are less than 1.0). If
  67.      an alignment value is 0.0 the widget is positioned to the left (or
  68.      top) of its allocated space. An alignment value of 1.0 positions
  69.      the widget to the right (or bottom) of its allocated space. A
  70.      common usage is to specify XALIGN and YALIGN to be 0.5 which
  71.      causes the widget to be centered within its allocated area.
  72.  
  73. Signals
  74. -------
  75.  
  76. Functions
  77. ---------
  78.  
  79.  - Function: guint gtk_alignment_get_type (void)
  80.      Returns the `GtkAlignment' type identifier.
  81.  
  82.  - Function: GtkWidget* gtk_alignment_new (gfloat XALIGN, gfloat
  83.           YALIGN, gfloat XSCALE, gfloat YSCALE)
  84.      Create a new `GtkAlignment' object and initialize it with the
  85.      values XALIGN, YALIGN, XSCALE and YSCALE. The new widget is
  86.      returned as a pointer to a `GtkWidget' object. `NULL' is returned
  87.      on failure.
  88.  
  89.  - Function: void gtk_alignment_set (GtkAlignment *ALIGNMENT, gfloat
  90.           XALIGN, gfloat YALIGN, gfloat XSCALE, gfloat YSCALE)
  91.      Set the XALIGN, YALIGN, XSCALE and YSCALE options of an alignment
  92.      widget. It is important to not set the fields of the
  93.      `GtkAlignment' structure directly (or, for that matter, any type
  94.      derived from `GtkObject').
  95.  
  96.  - Function: GtkAlignment* GTK_ALIGNMENT (gpointer OBJ)
  97.      Cast a generic pointer to `GtkAlignment*'. *Note Standard
  98.      Macros::, for more info.
  99.  
  100.  - Function: GtkAlignmentClass* GTK_ALIGNMENT_CLASS (gpointer CLASS)
  101.      Cast a generic pointer to `GtkAlignmentClass*'. *Note Standard
  102.      Macros::, for more info.
  103.  
  104.  - Function: gint GTK_IS_ALIGNMENT (gpointer OBJ)
  105.      Determine if a generic pointer refers to a `GtkAlignment' object.
  106.      *Note Standard Macros::, for more info.
  107.  
  108. 
  109. File: gtk.info,  Node: GtkArrow,  Next: GtkAspectFrame,  Prev: GtkAlignment,  Up: Widgets
  110.  
  111. The arrow widget
  112. ================
  113.  
  114. Description
  115. -----------
  116.  
  117.    The arrow widget is derived from the misc widget (*note GtkMisc::.)
  118. and is intended for use where a directional arrow (in one of the four
  119. cardinal directions) is desired. As such, it has very limited
  120. functionality and basically only draws itself in a particular direction
  121. and with a particular shadow type. The arrow widget will expand to fill
  122. all the space it is allocated.
  123.  
  124. Options
  125. -------
  126.  
  127.  - User Option: arrow_type
  128.      The ARROW_TYPE option specifies which direction the arrow will
  129.      point. It can be one of `GTK_ARROW_UP', `GTK_ARROW_DOWN',
  130.      `GTK_ARROW_LEFT' or `GTK_ARROW_RIGHT'. This will set the arrow
  131.      pointing in the direction specified.
  132.  
  133.  - User Option: shadow_type
  134.      The SHADOW_TYPE option specifies how to draw the shadow for the
  135.      arrow. Currently, only the `GTK_SHADOW_IN' and `GTK_SHADOW_OUT'
  136.      shadow types are supported for drawing arrows. Other shadow types
  137.      will cause nothing to be drawn.
  138.  
  139. Signals
  140. -------
  141.  
  142. Functions
  143. ---------
  144.  
  145.  - Function: guint gtk_arrow_get_type (void)
  146.      Returns the `GtkArrow' type identifier.
  147.  
  148.  - Function: GtkWidget* gtk_arrow_new (GtkArrowType ARROW_TYPE,
  149.           GtkShadowType SHADOW_TYPE)
  150.      Create a new `GtkArrow' object and initialize it with the values
  151.      ARROW_TYPE and SHADOW_TYPE. The new widget is returned as a
  152.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  153.  
  154.  - Function: void gtk_arrow_set (GtkArrow *ARROW, GtkArrowType
  155.           ARROW_TYPE, GtkShadowType SHADOW_TYPE)
  156.      Set the ARROW_TYPE and SHADOW_TYPE options of an arrow widget. It
  157.      is important to not set the fields of the `GtkArrow' structure
  158.      directly (or, for that matter, any type derived from `GtkObject').
  159.  
  160.  - Function: GtkArrow* GTK_ARROW (gpointer OBJ)
  161.      Cast a generic pointer to `GtkArrow*'. *Note Standard Macros::, for
  162.      more info.
  163.  
  164.  - Function: GtkArrowClass* GTK_ARROW_CLASS (gpointer CLASS)
  165.      Cast a generic pointer to `GtkArrowClass*'. *Note Standard
  166.      Macros::, for more info.
  167.  
  168.  - Function: gint GTK_IS_ARROW (gpointer OBJ)
  169.      Determine if a generic pointer refers to a `GtkArrow' object.
  170.      *Note Standard Macros::, for more info.
  171.  
  172. 
  173. File: gtk.info,  Node: GtkAspectFrame,  Next: GtkBin,  Prev: GtkArrow,  Up: Widgets
  174.  
  175. The aspect frame widget
  176. =======================
  177.  
  178. Description
  179. -----------
  180.  
  181.    Ensure that the child window has a specified aspect ratio or, if
  182. obey_child, has the same aspect ratio as its requested size.  Derived
  183. from *note GtkFrame::.).
  184.  
  185. Options
  186. -------
  187.  
  188.  - User Option: label
  189.  
  190.  - User Option: xalign
  191.  
  192.  - User Option: yalign
  193.  
  194.  - User Option: ratio
  195.  
  196.  - User Option: obey_child
  197.  
  198. Signals
  199. -------
  200.  
  201. Functions
  202. ---------
  203.  
  204.  - Function: guint gtk_aspect_frame_get_type (void)
  205.      Returns the `GtkAspectFrame' type identifier.
  206.  
  207.  - Function: GtkWidget* gtk_aspect_frame_new (gchar *LABEL, gfloat
  208.           XALIGN, gfloat YALIGN, gfloat RATIO, gint OBEY_CHILD)
  209.      Create a new `GtkAspectFrame' object and initialize it with the
  210.      values LABEL, XALIGN, YALIGN, RATIO and OBEY_CHILD.  The new
  211.      widget is returned as a pointer to a `GtkWidget' object.  `NULL'
  212.      is returned on failure.
  213.  
  214.  - Function: void gtk_aspect_frame_set (GtkAspectFrame *ASPECT_FRAME,
  215.           gfloat XALIGN, gfloat YALIGN, gfloat RATIO, gint OBEY_CHILD)
  216.  
  217.  - Function: GtkAspectFrame* GTK_ASPECT_FRAME (gpointer OBJ)
  218.      Cast a generic pointer to `GtkAspectFrame*'. *Note Standard
  219.      Macros::, for more info.
  220.  
  221.  - Function: GtkAspectFrameClass* GTK_ASPECT_FRAME_CLASS (gpointer
  222.           CLASS)
  223.      Cast a generic pointer to `GtkAspectFrameClass*'. *Note Standard
  224.      Macros::, for more info.
  225.  
  226.  - Function: gint GTK_IS_ASPECT_FRAME (gpointer OBJ)
  227.      Determine if a generic pointer refers to a `GtkAspectFrame'
  228.      object. *Note Standard Macros::, for more info.
  229.  
  230. 
  231. File: gtk.info,  Node: GtkBin,  Next: GtkBox,  Prev: GtkAspectFrame,  Up: Widgets
  232.  
  233. The bin widget
  234. ==============
  235.  
  236. Description
  237. -----------
  238.  
  239.    The bin widget is a container (*note GtkContainer::.) derived from
  240. the container widget. It is an abstract base class. That is, it is not
  241. possible to create an actual bin widget. It exists only to provide a
  242. base of functionality for other widgets. Specifically, the bin widget
  243. provides a base for several other widgets that contain only a single
  244. child. These widgets include alignments (*note GtkAlignment::.), frames
  245. (*note GtkFrame::.), items (*note GtkItem::.), viewports (*note
  246. GtkViewport::.) and windows (*note GtkWindow::.)
  247.  
  248. Options
  249. -------
  250.  
  251. Signals
  252. -------
  253.  
  254. Functions
  255. ---------
  256.  
  257.  - Function: guint gtk_bin_get_type (void)
  258.      Returns the `GtkBin' type identifier.
  259.  
  260.  - Function: GtkBin* GTK_BIN (gpointer OBJ)
  261.      Cast a generic pointer to `GtkBin*'. *Note Standard Macros::, for
  262.      more info.
  263.  
  264.  - Function: GtkBinClass* GTK_BIN_CLASS (gpointer CLASS)
  265.      Cast a generic pointer to `GtkBinClass*'. *Note Standard Macros::,
  266.      for more info.
  267.  
  268.  - Function: gint GTK_IS_BIN (gpointer OBJ)
  269.      Determine if a generic pointer refers to a `GtkBin' object. *Note
  270.      Standard Macros::, for more info.
  271.  
  272. 
  273. File: gtk.info,  Node: GtkBox,  Next: GtkButtonBox,  Prev: GtkBin,  Up: Widgets
  274.  
  275. The box widget
  276. ==============
  277.  
  278. Description
  279. -----------
  280.  
  281.    The box widget is a container (*note GtkContainer::.) derived from
  282. the container widget. It is an abstract base class used by the
  283. horizontal box (*note GtkHBox::.), the vertical box (*note GtkVBox::.)
  284. and the (*note GtkButtonBox::.) widgets to provide a base of common
  285. functionality.
  286.  
  287.    A box provides an abstraction for organizing the position and size of
  288. widgets. Widgets in a box are laid out horizontally or vertically. By
  289. using a box widget appropriately, a programmer can control how widgets
  290. are positioned and how they will be allocated space when a window gets
  291. resized.
  292.  
  293.    The key attribute of boxes is that they position their children in a
  294. single row (horizontal boxes) or column (vertical boxes). In the case of
  295. horizontal boxes, all children are stretched vertically. The vertical
  296. size of the box is determined by the largest vertical requisition of all
  297. of its children. Similarly, a vertical box stretches all of its children
  298. horizontally. The horizontal size (of the vertical box) is determined by
  299. the largest horizontal requisition of all of its children. An alignment
  300. widget (*note GtkAlignment::.) can be used to control child allocation
  301. more precisely on a per child basis.
  302.  
  303.    The second attribute of boxes is how they expand children. In the
  304. case of a horizontal box, the main control is over how children are
  305. expanded horizontally to fill the allocated area. (The rest of this
  306. discussion will focus on horizontal boxes but it applies to vertical
  307. boxes as well).
  308.  
  309.    There are two flags which can be set controlling how a widget is
  310. expanded horizontally in a horizontal box. These are the `expand' and
  311. `fill'. There operation is fairly simple. If `expand' is set, the
  312. child's potentially allocated area will expand to fill available space.
  313. If `fill' is set, the child's actual allocated area will be its
  314. potentially allocated area. There is a difference between the
  315. potentially area (which is the area the box widget sets aside for the
  316. child) and the actual allocated area (which is the area the box widget
  317. actual allocates for the widget via `gtk_widget_size_allocate').
  318.  
  319.    The allocation of space to children occurs as follows (for horizontal
  320. boxes):
  321.   1. All children are allocated at least their requested size
  322.      horizontally and the maximum requested child size vertically.
  323.  
  324.   2. Any child with the `expand' flag set is allocated `extra_width /
  325.      nexpand_children' extra pixels horizontally. If the `homogeneous'
  326.      flag was set, all children are considered to have the `expand' flag
  327.      set. That is, all children will be allocated the same area.The
  328.      horizontal box is a fair widget and, as such, divides up any extra
  329.      allocated space evenly among the "expand" children. (Those children
  330.      which have the `expand' flag set). The exception occurs when
  331.      `extra_width / nexpand_children' does not divide cleanly. The extra
  332.      space is given to the last widget.
  333.  
  334.   3. `spacing' number of pixels separate each child. Note: The
  335.      separation is between the potentially allocated area for each
  336.      child and not the actual allocated area. The `padding' value
  337.      associated with each child causes that many pixels to be left
  338.      empty to each side of the child.
  339.  
  340.   4. If a child has the `fill' flag set it is allocated its potentially
  341.      allocated area. If it does not, it is allocated its requested size
  342.      horizontally and centered within its potentially allocated area.
  343.      Its vertical allocation is still the maximum requested size of any
  344.      child.
  345.  
  346.   5. Children placed at the start of the box are placed in order of
  347.      addition to the box from left to right in the boxes allocated
  348.      area.. Children placed at the end of the box are placed in order
  349.      of addition from right to left in the boxes allocated area.
  350.  
  351.    *Note GtkHBox::, and *Note GtkVBox::, for code examples of using
  352. horizontal and vertical boxes.
  353.  
  354. Options
  355. -------
  356.  
  357.  - User Option: expand
  358.  
  359.  - User Option: fill
  360.  
  361.  - User Option: padding
  362.  
  363.  - User Option: expand
  364.  
  365. Signals
  366. -------
  367.  
  368. Functions
  369. ---------
  370.  
  371.  - Function: guint gtk_box_get_type (void)
  372.      Returns the `GtkBox' type identifier.
  373.  
  374.  - Function: void gtk_box_pack_start (GtkBox *BOX, GtkWidget *CHILD,
  375.           gint EXPAND, gint FILL, gint PADDING)
  376.      Add CHILD to the front of BOX. The flags EXPAND and FILL and the
  377.      padding value of PADDING are associated with CHILD.
  378.  
  379.  - Function: void gtk_box_pack_end (GtkBox *BOX, GtkWidget *CHILD, gint
  380.           EXPAND, gint FILL, gint PADDING)
  381.      Add CHILD to the end of BOX. The flags EXPAND and FILL and the
  382.      padding value of PADDING are associated with CHILD.
  383.  
  384.  - Function: void gtk_box_pack_start_defaults (GtkBox *BOX, GtkWidget
  385.           *WIDGET)
  386.      A convenience function which is equivalent to the following:
  387.  
  388.             gtk_box_pack_start (BOX, WIDGET, TRUE, TRUE, 0);
  389.  
  390.  - Function: void gtk_box_pack_end_defaults (GtkBox *BOX, GtkWidget
  391.           *WIDGET)
  392.      A convenience function which is equivalent to the following:
  393.  
  394.             gtk_box_pack_start (BOX, WIDGET, TRUE, TRUE, 0);
  395.  
  396.  - Function: void gtk_box_set_homogeneous (GtkBox *BOX, gint
  397.           HOMOGENEOUS)
  398.      Set the homogeneous setting of this box to HOMOGENEOUS.
  399.  
  400.  - Function: void gtk_box_set_spacing (GtkBox *BOX, gint SPACING)
  401.  
  402.  - Function: void gtk_box_reorder_child (GtkBox *BOX, GtkWidget *CHILD,
  403.           guint POS)
  404.  
  405.  - Function: void gtk_box_query_child_packing (GtkBox *BOX, GtkWidget
  406.           *CHILD, gint *EXPAND, gint *FILL, gint *PADDING, GtkPackType
  407.           *PACK_TYPE)
  408.  
  409.  - Function: void gtk_box_set_child_packing (GtkBox *BOX, GtkWidget
  410.           *CHILD, gint EXPAND, gint FILL, gint PADDING, GtkPackType
  411.           *PACK_TYPE)
  412.  
  413.  - Function: GtkBox* GTK_BOX (gpointer OBJ)
  414.      Cast a generic pointer to `GtkBox*'. *Note Standard Macros::, for
  415.      more info.
  416.  
  417.  - Function: GtkBoxClass* GTK_BOX_CLASS (gpointer CLASS)
  418.      Cast a generic pointer to `GtkBoxClass*'. *Note Standard Macros::,
  419.      for more info.
  420.  
  421.  - Function: gint GTK_IS_BOX (gpointer OBJ)
  422.      Determine if a generic pointer refers to a `GtkBox' object. *Note
  423.      Standard Macros::, for more info.
  424.  
  425. 
  426. File: gtk.info,  Node: GtkButtonBox,  Next: GtkButton,  Prev: GtkBox,  Up: Widgets
  427.  
  428. The button box widget
  429. =====================
  430.  
  431. Description
  432. -----------
  433.  
  434.    The button box widget is a container (*note GtkContainer::.) derived
  435. from the (*note GtkBox::.) widget. It is an abstract base class used by
  436. the horizontal button box (*note GtkHButtonBox::.) and the vertical
  437. button box (*note GtkVButtonBox::.) widgets to provide a base of common
  438. functionality.
  439.  
  440.    The button box, like the box widget, (*note GtkBox::.) provides an
  441. abstraction for organizing position and size of widgets. In the case of
  442. the button box it is targeted at the button widget,(*note
  443. GtkButton::.). Button widgets are laid out in the box horizontally or
  444. vertically. By using a button box widget appropriately, a programmer
  445. can control how the button widgets are positioned and how they will be
  446. allocated space when a window gets resized.
  447.  
  448. Options
  449. -------
  450.  
  451.  - User Option: layout_style
  452.              * `GTK_BUTTONBOX_SPREAD'
  453.  
  454.         * The layout style `GTK_BUTTONBOX_SPREAD' will spread the
  455.           buttons out evenly within the button box. When the parent
  456.           window is resized they will re-adjust to the new window
  457.           dimensions. The `gtk_button_box_set_spacing' function will
  458.           set the minimum space that the buttons will leave between
  459.           themselves.
  460.  
  461.              * `GTK_BUTTONBOX_EDGE'
  462.  
  463.         *             * `GTK_BUTTONBOX_START'
  464.  
  465.         * The layout style `GTK_BUTTONBOX_START' will place the buttons
  466.           at the start of the button box, taking into account the
  467.           spacing as set by the `gtk_button_box_set_spacing' function.
  468.           The buttons will not move when the parent window is re-sized.
  469.  
  470.              * `GTK_BUTTONBOX_END'
  471.  
  472.         * The layout style `GTK_BUTTONBOX_END' will place the buttons
  473.           at the end of the button box, taking into account the spacing
  474.           as set by the `gtk_button_box_set_spacing' function. Again
  475.           like the `GTK_BUTTONBOX_START' layout style the buttons will
  476.           not move when the parent window is re-sized.
  477.  
  478.  - User Option: width
  479.  
  480.  - User Option: height
  481.  
  482.  - User Option: ipad_x
  483.  - User Option: ipad_y
  484.  
  485. Signals
  486. -------
  487.  
  488. Functions
  489. ---------
  490.  
  491.  - Function: guint gtk_button_box_get_type (void)
  492.      Returns the `GtkButtonBox' type identifier.
  493.  
  494.  - Function: void gtk_button_box_set_child_size_default (gint WIDTH,
  495.           gintHEIGHT)
  496.  
  497.  - Function: void gtk_button_box_set_child_ipadding_default (gint
  498.           IPAD_X, gint IPAD_Y)
  499.  
  500.  - Function: void gtk_button_box_get_child_size_default (gint *WIDTH,
  501.           gint *HEIGHT)
  502.  
  503.  - Function: void gtk_button_box_get_child_ipadding_default (gint
  504.           *IPAD_X, gint *IPAD_Y)
  505.  
  506.  - Function: void gtk_button_box_set_child_size (GtkButtonBox *WIDGET,
  507.           gint WIDTH, gint HEIGHT)
  508.  
  509.  - Function: void gtk_button_box_set_child_ipadding (GtkButtonBox
  510.           *WIDGET, gint IPAD_X, gint IPAD_Y)
  511.  
  512.  - Function: void gtk_button_box_set_layout (GtkButtonBox *WIDGET, gint
  513.           LAYOUT_STYLE)
  514.      This will set the layout style of the buttons within this box.
  515.      Currently it can be set to one of `GTK_BUTTONBOX_SPREAD',
  516.      `GTK_BUTTONBOX_EDGE', `GTK_BUTTONBOX_START' or `GTK_BUTTONBOX_END'.
  517.  
  518.      The following example:
  519.               gtk_button_box_set_layout (GTK_BUTTON_BOX (box),
  520.                                          GTK_BUTTONBOX_SPREAD);
  521.      Will set the BOX argument to the "SPREAD" layout style described
  522.      above.
  523.  
  524.  - Function: gint gtk_button_box_get_spacing (GtkButtonBox *WIDGET)
  525.      Get the per widget value for spacing within the button box. This
  526.      value is the amount of space that will be between the individual
  527.      buttons contained by this box.
  528.  
  529.  - Function: void gtk_button_box_get_child_size (GtkButtonBox *WIDGET,
  530.           gint *WIDTH, gint *HEIGHT)
  531.  
  532.  - Function: void gtk_button_box_get_child_ipadding (GtkButtonBox
  533.           *WIDGET, gint *IPAD_X, gint *IPAD_Y)
  534.      Get the per widget value for the padding inside the buttons. This
  535.      value controls how large the buttons will be within the box.
  536.  
  537.  - Function: gint gtk_button_box_get_layout (GtkButtonBox *WIDGET)
  538.      Get the LAYOUT_STYLE for the `GtkButtonBox' object passed to this
  539.      function in the WIDGET variable.
  540.  
  541.              layout = gtk_button_box_get_layout(GTK_BUTTON_BOX (box));
  542.  
  543.  
  544.  - Function: GtkButtonBox* GTK_BUTTON_BOX (gpointer OBJ)
  545.      Cast a generic pointer to `GtkButtonBox*'. *Note Standard
  546.      Macros::, for more info.
  547.  
  548.  - Function: GtkButtonBoxClass* GTK_BUTTON_BOX_CLASS (gpointer CLASS)
  549.      Cast a generic pointer to `GtkButtonBoxClass*'. *Note Standard
  550.      Macros::, for more info.
  551.  
  552.  - Function: gint GTK_IS_BUTTON_BOX (gpointer OBJ)
  553.      Determine if a generic pointer refers to a `GtkButtonBox' object.
  554.      *Note Standard Macros::, for more info.
  555.  
  556. 
  557. File: gtk.info,  Node: GtkButton,  Next: GtkCheckButton,  Prev: GtkButtonBox,  Up: Widgets
  558.  
  559. The button widget
  560. =================
  561.  
  562. Description
  563. -----------
  564.  
  565.    A pressable button.  Contains a widget.  Changes its appearance
  566. (hilites) when it gets the focus.  Changes its appearance (pressed) when
  567. activated.  Derived from *note GtkContainer::..
  568.  
  569. Signals
  570. -------
  571.  
  572.  - Signal: void GtkButton::pressed (GtkButton *BUTTON)
  573.  
  574.  - Signal: void GtkButton::released (GtkButton *BUTTON)
  575.  
  576.  - Signal: void GtkButton::clicked (GtkButton *BUTTON)
  577.  
  578.  - Signal: void GtkButton::enter (GtkButton *BUTTON)
  579.  
  580.  - Signal: void GtkButton::leave (GtkButton *BUTTON)
  581.  
  582. Functions
  583. ---------
  584.  
  585.  - Function: guint gtk_button_get_type (void)
  586.      Returns the `GtkButton' type identifier.
  587.  
  588.  - Function: GtkWidget* gtk_button_new (void)
  589.      Create a new `GtkButton' object. The new widget is returned as a
  590.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  591.  
  592.  - Function: GtkWidget* gtk_button_new_with_label (gchar *LABEL)
  593.      Create a new `GtkButton' object and set the text that is on the
  594.      button to LABEL. The new widget is returned as a pointer to a
  595.      `GtkWidget' object. `NULL' is returned on failure.
  596.  
  597.  - Function: void gtk_button_pressed (GtkButton *BUTTON)
  598.  
  599.  - Function: void gtk_button_released (GtkButton *BUTTON)
  600.  
  601.  - Function: void gtk_button_clicked (GtkButton *BUTTON)
  602.  
  603.  - Function: void gtk_button_enter (GtkButton *BUTTON)
  604.  
  605.  - Function: void gtk_button_leave (GtkButton *BUTTON)
  606.  
  607.  - Function: GtkButton* GTK_BUTTON (gpointer OBJ)
  608.      Cast a generic pointer to `GtkButton*'. *Note Standard Macros::,
  609.      for more info.
  610.  
  611.  - Function: GtkButtonClass* GTK_BUTTON_CLASS (gpointer CLASS)
  612.      Cast a generic pointer to `GtkButtonClass*'. *Note Standard
  613.      Macros::, for more info.
  614.  
  615.  - Function: gint GTK_IS_BUTTON (gpointer OBJ)
  616.      Determine if a generic pointer refers to a `GtkButton' object.
  617.      *Note Standard Macros::, for more info.
  618.  
  619. 
  620. File: gtk.info,  Node: GtkCheckButton,  Next: GtkCheckMenuItem,  Prev: GtkButton,  Up: Widgets
  621.  
  622. The check button widget
  623. =======================
  624.  
  625. Description
  626. -----------
  627.  
  628.    Another form of toggle button (*note GtkToggleButton::.) with an
  629. indicator.  Contains a widget to the right of the indicator.  Changes
  630. its appearance (hilites) when it gets the focus.
  631.  
  632. Options
  633. -------
  634.  
  635. Signals
  636. -------
  637.  
  638. Functions
  639. ---------
  640.  
  641.  - Function: guint gtk_check_button_get_type (void)
  642.      Returns the `GtkCheckButton' type identifier.
  643.  
  644.  - Function: GtkWidget* gtk_check_button_new (void)
  645.      Create a new `GtkCheckButton' object and initialize it with the
  646.      default values in the library. The new widget is returned as a
  647.      pointer to a `GtkWidget' object. A `NULL' is returned on failure.
  648.  
  649.  - Function: GtkWidget* gtk_check_button_new_with_label (gchar *LABEL)
  650.      Create a new `GtkCheckButton' object and initialize it with the
  651.      values LABEL. The new widget is returned as a pointer to a
  652.      `GtkWidget' object. `NULL' is returned on any failure.
  653.  
  654.  - Function: GtkCheckButton* GTK_CHECK_BUTTON (gpointer OBJ)
  655.  
  656.  - Function: GtkCheckButtonClass* GTK_CHECK_BUTTON_CLASS (gpointer
  657.           CLASS)
  658.  
  659.  - Function: gint GTK_IS_CHECK_BUTTON (gpointer OBJ)
  660.  
  661.  - Function: GtkCheckButton* GTK_CHECK_BUTTON (gpointer OBJ)
  662.      Cast a generic pointer to `GtkCheckButton*'. *Note Standard
  663.      Macros::, for more info.
  664.  
  665.  - Function: GtkCheckButtonClass* GTK_CHECK_BUTTON_CLASS (gpointer
  666.           CLASS)
  667.      Cast a generic pointer to `GtkCheckButtonClass*'. *Note Standard
  668.      Macros::, for more info.
  669.  
  670.  - Function: gint GTK_IS_CHECK_BUTTON (gpointer OBJ)
  671.      Determine if a generic pointer refers to a `GtkCheckButton'
  672.      object. *Note Standard Macros::, for more info.
  673.  
  674. 
  675. File: gtk.info,  Node: GtkCheckMenuItem,  Next: GtkCList,  Prev: GtkCheckButton,  Up: Widgets
  676.  
  677. The check menu item widget
  678. ==========================
  679.  
  680. Description
  681. -----------
  682.  
  683.    Derived from *note GtkMenuItem::..  Very similar to a checkbutton
  684. (*note GtkCheckButton::.), except that it's a menu item.  Has a toggled
  685. state which is displayed in a small rectangle to the left of the
  686. contained widget.
  687.  
  688. Options
  689. -------
  690.  
  691.  - User Option: label
  692.  
  693.  - User Option: state
  694.  
  695. Signals
  696. -------
  697.  
  698.  - Signal: void GtkCheckMenuItem::toggled (GtkCheckMenuItem
  699.           *CHECK_MENU_ITEM)
  700.  
  701. Functions
  702. ---------
  703.  
  704.  - Function: guint gtk_check_menu_item_get_type (void)
  705.      Returns the `GtkCheckMenuItem' type identifier.
  706.  
  707.  - Function: GtkWidget* gtk_check_menu_item_new (void)
  708.      Create a new `GtkCheckMenuItem' object. The new widget is returned
  709.      as a pointer to a `GtkWidget' object. `NULL' is returned on
  710.      failure.
  711.  
  712.  - Function: GtkWidget* gtk_check_menu_item_new_with_label (gchar
  713.           *LABEL)
  714.      Create a new `GtkCheckMenuItem' object and initialize it with the
  715.      values LABEL. The new widget is returned as a pointer to a
  716.      `GtkWidget' object. `NULL' is returned on failure.
  717.  
  718.  - Function: void gtk_check_menu_item_set_state (GtkCheckMenuItem
  719.           *CHECK_MENU_ITEM, gint STATE)
  720.  
  721.  - Function: void gtk_check_menu_item_toggled (GtkCheckMenuItem
  722.           *CHECK_MENU_ITEM)
  723.  
  724.  - Function: GtkCheckMenuItem* GTK_CHECK_MENU_ITEM (gpointer OBJ)
  725.      Cast a generic pointer to `GtkCheckMenuItem*'. *Note Standard
  726.      Macros::, for more info.
  727.  
  728.  - Function: GtkCheckMenuItemClass* GTK_CHECK_MENU_ITEM_CLASS (gpointer
  729.           CLASS)
  730.      Cast a generic pointer to `GtkCheckMenuItemClass*'. *Note Standard
  731.      Macros::, for more info.
  732.  
  733.  - Function: gint GTK_IS_CHECK_MENU_ITEM (gpointer OBJ)
  734.      Determine if a generic pointer refers to a `GtkCheckMenuItem'
  735.      object. *Note Standard Macros::, for more info.
  736.  
  737. 
  738. File: gtk.info,  Node: GtkCList,  Next: GtkColorSelection,  Prev: GtkCheckMenuItem,  Up: Widgets
  739.  
  740. The compound list widget
  741. ========================
  742.  
  743. Description
  744. -----------
  745.  
  746.    A list of rows of columns, with a title row.  You can insert rows,
  747. and delete rows.  The user can scroll around and select a row.  Derived
  748. from *note GtkContainer::..  Cells can be empty, have a text and/or
  749. pixmap, or be a widget.
  750.  
  751. Options
  752. -------
  753.  
  754. Signals
  755. -------
  756.  
  757. Functions
  758. ---------
  759.  
  760.  - Function: guint gtk_clist_get_type (void)
  761.      Returns the `GtkCList' type identifier.
  762.  
  763.  - Function: GtkWidget* gtk_clist_new (int COLUMNS)
  764.      Create a new `GtkCList' initializing it with the value COLUMNS.
  765.      The new widget is returned as a pointer to a `GtkWidget' object.
  766.      `NULL' is returned on failure.
  767.  
  768.  - Function: GtkWidget* gtk_clist_new_with_titles (int COLUMNS, gchar
  769.           *TITLES[])
  770.  
  771.  - Function: void gtk_clist_set_border (GtkCList *CLIST, GtkShadowType
  772.           BORDER)
  773.      Set the border style of the CLIST to the shadow type BORDER.
  774.  
  775.  - Function: void gtk_clist_set_selection_mode (GtkCList *CLIST
  776.           GtkSelectionMode MODE)
  777.      Set the selection mode on the CLIST to the MODE selection mode.
  778.  
  779.  - Function: void gtk_clist_set_policy (GtkCList *CLIST, GtkPolicyType
  780.           VSCROLLBAR_POLICY, GtkPolicyType HSCROLLBAR_POLICY)
  781.      Set the policy on the scrollbars on the CLIST to VSCROLLBAR_POLICY
  782.      and HSCROLLBAR_POLICY.
  783.  
  784.  - Function: void gtk_clist_freeze (GtkCList *CLIST)
  785.      Stop all visual updates of the CLIST. Useful for when making a
  786.      large number of changes to a `GtkCList'.
  787.  
  788.  - Function: void gtk_clist_thaw (GtkCList *CLIST)
  789.      Allow all visual updates of the CLIST to resume.
  790.  
  791.  - Function: void gtk_clist_column_titles_show (GtkCList *CLIST)
  792.      Show the column title buttons on the CLIST.
  793.  
  794.  - Function: void gtk_clist_column_titles_hide (GtkCList *CLIST)
  795.      Hide the column title buttons on the CLIST.
  796.  
  797.  - Function: void gtk_clist_set_column_title (GtkCList *CLIST, gint
  798.           COLUMN, gchar *TITLE)
  799.      Set the title in column COLUMN of the CLIST button to TITLE.
  800.  
  801.  - Function: void gtk_clist_set_column_widget (GtkCList *CLIST, gint
  802.           COLUMN, GtkWidget *WIDGET)
  803.      Set the WIDGET instead of the title button for the column COLUMN
  804.      in the CLIST.
  805.  
  806.  - Function: void gtk_clist_set_column_justification (GtkCList *CLIST,
  807.           gint COLUMN, GtkJustification JUSTIFICATION)
  808.      Set the COLUMN's justification, in the CLIST to JUSTIFICATION.
  809.  
  810.  - Function: void gtk_clist_set_column_width (GtkCList *CLIST, gint
  811.           COLUMN, gint WIDTH)
  812.      Set the pixel width of column COLUMN in the `GtkCList' CLIST to
  813.      WIDTH. This function is a necessary step in creating a `GtkCList'
  814.      because otherwise the column width is chosen from the width of the
  815.      column title, which is almost never correct.
  816.  
  817.  - Function: void gtk_clist_set_row_height (GtkCList *CLIST, gint
  818.           HEIGHT)
  819.      Change the height of the rows in the CLIST to HEIGHT. The default
  820.      is the height of the current font.
  821.  
  822.  - Function: void gtk_clist_moveto (GtkCList *CLIST, gint ROW,
  823.           gintCOLUMN, gfloat ROW_ALIGN, gfloat COL_ALIGN)
  824.      Scroll the viewing area of the `GtkClist' in CLIST to COLUMN and
  825.      ROW. The ROW_ALIGN and COL_ALIGN are between zero and one,
  826.      representing the location the row should appear on screen. Setting
  827.      ROW_ALIGN or the COL_ALIGN to 0.0 will be the top or left of the
  828.      viewing area. Setting the ROW_ALIGN or COL_ALIGN to 1.0 will be
  829.      the bottom or right of the viewing area. If the ROW or COLUMN is
  830.      -1 then there is no change.
  831.  
  832.  - Function: void gtk_clist_set_text (GtkCList *CLIST, gint ROW, gint
  833.           COLUMN, gchar *TEXT)
  834.      Set a given cell's text, located by the ROW and COLUMN, to TEXT
  835.      replacing its current contents.
  836.  
  837.  - Function: void gtk_clist_set_pixmap (GtkCList *CLIST, gint ROW, gint
  838.           COLUMN, GdkPixmap *PIXMAP, GdkBitmap *MASK)
  839.      Set a given cell's text, located by the COLUMN and ROW arguments,
  840.      to the pixmap described by the PIXMAP argument using the MASK as
  841.      its mask. The current contents of the cell will be replaced.
  842.  
  843.  - Function: void gtk_clist_setpixtext (GtkCList *CLIST, gint ROW, gint
  844.           COLUMN, gchar *TEXT, guint8 SPACING, GdkPixmap *PIXMAP,
  845.           GdkBitmap *MASK)
  846.      Set a given cell's text and pixmap, located by the ROW and COLUMN
  847.      arguments, to the text and pixmap described by the PIXMAP and TEXT
  848.      arguments. The MASK will be used for the pixmap mask and the
  849.      SPACING argument specifies the spacing between the two.
  850.  
  851.  - Function: void gtk_clist_set_foreground (GtkCList *CLIST, gint ROW,
  852.           GdkColor *COLOR)
  853.      Set the foreground color of row ROW to COLOR in the `GtkCList'
  854.      CLIST. The COLOR must already be allocated.
  855.  
  856.  - Function: void gtk_clist_set_background (GtkCList *CLIST, gint ROW,
  857.           GdkColor *COLOR)
  858.      Set the background color of row ROW to COLOR in the `GtkCList'
  859.      pointed to by CLIST. The color must be previously allocated.
  860.  
  861.  - Function: void gtk_clist_set_shift (GtkCList *CLIST, gint ROW, gint
  862.           COLUMN, gint VERTICAL, gint HORIZONTAL)
  863.      Set the horizontal and vertical shift for drawing the contents of
  864.      the cell located at ROW and COLUMN. The VERTICAL and HORIZONTAL
  865.      arguments can be positive or negative.
  866.  
  867.  - Function: gint gtk_clist_append (GtkCList *CLIST, gchar *TEXT[])
  868.      Append the given text, in the TEXT[] argument,  to the `GtkCList'
  869.      pointed to by the CLIST. The return value is the index of the row
  870.      that was just added.
  871.  
  872.  - Function: void gtk_clist_insert (GtkCList *CLIST, gint ROW, gchar
  873.           *TEXT[])
  874.      Insert a row into the `GtkCList' pointed to by CLIST at row ROW
  875.      with the text in TEXT[].
  876.  
  877.  - Function: void gtk_clist_remove (GtkCList *CLIST, gint ROW)
  878.      Remove row index ROW from the CLIST.
  879.  
  880.  - Function: void gtk_clist_set_row_data (GtkCList *CLIST, gint ROW,
  881.           gpointer DATA)
  882.      Will set an arbitrary data pointer, DATA, for row ROW in the
  883.      `GtkCList' pointed to by CLIST.
  884.  
  885.  - Function: gpointer gtk_clist_get_row_data (GtkCList *CLIST, gint ROW)
  886.      Return the data that was set for row ROW from the `GtkCList'
  887.      pointed to by CLIST. `NULL' is returned if no data was set.
  888.  
  889.  - Function: void gtk_clist_select_row (GtkCList *CLIST, gint ROW, gint
  890.           COLUMN)
  891.      Force selection of a row, located by ROW and COLUMN, in the
  892.      `GtkCList' pointed to by CLIST.
  893.  
  894.  - Function: void gtk_clist_unselect_row (GtkCList *CLIST, gint ROW,
  895.           gint COLUMN)
  896.      Force the unselection of a row, located by ROW and COLUMN, in the
  897.      `GtkCList' pointed to by CLIST.
  898.  
  899.  - Function: void gtk_clist_clear (GtkCList *CLIST)
  900.      Clear the entire contents of the `GtkCList' pointed to by CLIST.
  901.      This is much faster then removing each item separately with
  902.      `gtk_clist_remove'.
  903.  
  904.  - Function: GtkCList* GTK_CLIST (gpointer OBJ)
  905.      Cast a generic pointer to `GtkCList*'. *Note Standard Macros::, for
  906.      more info.
  907.  
  908.  - Function: GtkCListClass* GTK_CLIST_CLASS (gpointer CLASS)
  909.      Cast a generic pointer to `GtkCListClass*'. *Note Standard
  910.      Macros::, for more info.
  911.  
  912.  - Function: gint GTK_IS_CLIST (gpointer OBJ)
  913.      Determine if a generic pointer refers to a `GtkCList' object.
  914.      *Note Standard Macros::, for more info.
  915.  
  916. 
  917. File: gtk.info,  Node: GtkColorSelection,  Next: GtkCombo,  Prev: GtkCList,  Up: Widgets
  918.  
  919. The color selector widget
  920. =========================
  921.  
  922. Description
  923. -----------
  924.  
  925.    A widget that allows a user to pick a color in one of many ways.
  926. They can click on a color wheel or saturation bar.  They can change hue,
  927. saturation, value, red, green, or blue with a slider, or by entering
  928. values.  Also allows the user to set an alpha (opacity) value.  Derived
  929. from *note GtkVBox::..
  930.  
  931. Options
  932. -------
  933.  
  934.  - User Option: policy
  935.         * GTK_UPDATE_CONTINUOUS
  936.  
  937.         * GTK_UPDATE_DISCONTINUOUS
  938.  
  939.         * GTK_UPDATE_DELAYED
  940.  
  941.  - User Option: color
  942.  
  943.  - User Option: use_opacity
  944.  
  945.  - User Option: title
  946.  
  947. Signals
  948. -------
  949.  
  950. Functions
  951. ---------
  952.  
  953.  - Function: guint gtk_color_selection_get_type (void)
  954.      Returns the `GtkColorSelection' type identifier.
  955.  
  956.  - Function: GtkWidget* gtk_color_selection_new (void)
  957.      Create a new `GtkColorSelection' object. The new object is
  958.      returned as a pointer to a `GtkWidget' object. `NULL' is returned
  959.      on failure.
  960.  
  961.  - Function: void gtk_color_selection_set_update_policy
  962.           (GtkColorSelection *COLORSEL, GtkUpdateType POLICY)
  963.  
  964.  - Function: void gtk_color_selection_set_color (GtkColorSelection
  965.           *COLORSEL, gdouble *COLOR)
  966.  
  967.  - Function: void gtk_color_selection_get_color (GtkColorSelection
  968.           *COLORSEL, gdouble *COLOR)
  969.  
  970.  - Function: void gtk_color_selection_set_opacity (GtkColorSelection
  971.           *COLORSEL, gint USE_OPACITY)
  972.  
  973.  - Function: guint gtk_color_selection_dialog_get_type (void)
  974.      Returns the `GtkColorSelection' type identifier.
  975.  
  976.  - Function: GtkWidget* gtk_color_selection_dialog_new (gchar *TITLE)
  977.      Create a new `GtkColorSelection' object initializing the title bar
  978.      of the resulting dialog to TITLE. The new widget is returned as a
  979.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  980.  
  981.  - Function: GtkColorSelection* GTK_COLOR_SELECTION (gpointer OBJ)
  982.      Cast a generic pointer to `GtkColorSelection*'. *Note Standard
  983.      Macros::, for more info.
  984.  
  985.  - Function: GtkColorSelectionClass* GTK_COLOR_SELECTION_CLASS
  986.           (gpointer CLASS)
  987.      Cast a generic pointer to `GtkColorSelectionClass*'. *Note
  988.      Standard Macros::, for more info.
  989.  
  990.  - Function: gint GTK_IS_COLOR_SELECTION (gpointer OBJ)
  991.      Determine if a generic pointer refers to a `GtkColorSelection'
  992.      object. *Note Standard Macros::, for more info.
  993.  
  994. 
  995. File: gtk.info,  Node: GtkCombo,  Next: GtkContainer,  Prev: GtkColorSelection,  Up: Widgets
  996.  
  997. The combo widget
  998. ================
  999.  
  1000. Description
  1001. -----------
  1002.  
  1003.    Text input box which also lets you choose from pre-defined values
  1004. from a drop-down menu.  Derived from *note GtkHBox::..
  1005.  
  1006. Options
  1007. -------
  1008.  
  1009. Signals
  1010. -------
  1011.  
  1012. Functions
  1013. ---------
  1014.  
  1015.  - Function: guint gtk_combo_get_type (void)
  1016.      Returns the `GtkCombo' type identifier.
  1017.  
  1018.  - Function: GtkWidget* gtk_combo_new (void)
  1019.      Create a new `GtkCombo' object returning the new widget as a
  1020.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  1021.  
  1022.  - Function: void gtk_combo_set_value_in_list (GtkCombo *COMBO, gint
  1023.           VAL, gint OK_IF_EMPTY)
  1024.  
  1025.  - Function: void gtk_combo_set_use_arrows (GtkCombo *COMBO, gint VAL)
  1026.  
  1027.  - Function: void gtk_combo_set_use_arrows_always (GtkCombo *COMBO,
  1028.           gint VAL)
  1029.  
  1030.  - Function: void gtk_combo_set_case_sensitive (GtkCombo *COMBO, gint
  1031.           VAL)
  1032.  
  1033.  - Function: void gtk_combo_set_item_string (GtkCombo *COMBO, GtkItem
  1034.           *ITEM, gchar *ITEM_VALUE)
  1035.  
  1036.  - Function: void gtk_combo_set_popdown_strings (GtkCombo *COMBO, GList
  1037.           *STRINGS)
  1038.  
  1039.  - Function: GtkCombo* GTK_COMBO (gpointer OBJ)
  1040.      Cast a generic pointer to `GtkCombo*'. *Note Standard Macros::, for
  1041.      more info.
  1042.  
  1043.  - Function: GtkComboClass* GTK_COMBO_CLASS (gpointer CLASS)
  1044.      Cast a generic pointer to `GtkComboClass*'. *Note Standard
  1045.      Macros::, for more info.
  1046.  
  1047.  - Function: gint GTK_IS_COMBO (gpointer OBJ)
  1048.      Determine if a generic pointer refers to a `GtkCombo' object.
  1049.      *Note Standard Macros::, for more info.
  1050.  
  1051. 
  1052. File: gtk.info,  Node: GtkContainer,  Next: GtkCTree,  Prev: GtkCombo,  Up: Widgets
  1053.  
  1054. The container widget
  1055. ====================
  1056.  
  1057. Description
  1058. -----------
  1059.  
  1060.    A base class for objects that are built out of other widgets.  Many
  1061. widgets are containers.  For example, a button contains a widget.  That
  1062. widget might be a text label (usually is), or a pixmap, or even an hbox
  1063. which has a label and a pixmap.
  1064.  
  1065. Options
  1066. -------
  1067.  
  1068.  - User Option: border_width
  1069.  
  1070. Signals
  1071. -------
  1072.  
  1073.  - Signal: void GtkContainer::add (GtkContainer *CONTAINER, GtkWidget
  1074.           *WIDGET)
  1075.  
  1076.  - Signal: void GtkContainer::remove (GtkContainer *CONTAINER,
  1077.           GtkWidget *WIDGET)
  1078.  
  1079.  - Signal: void GtkContainer::need_resize (GtkContainer *CONTAINER,
  1080.           GtkWidget *WIDGET)
  1081.  
  1082.  - Signal: void GtkContainer::foreach (GtkContainer *CONTAINER,
  1083.           GtkCallback CALLBACK, gpointer CALLBACK_DATA)
  1084.  
  1085.  - Signal: gint GtkContainer::focus (GtkContainer *CONTAINER,
  1086.           GtkDirectionType DIRECTION)
  1087.  
  1088. Functions
  1089. ---------
  1090.  
  1091.  - Function: guint gtk_container_get_type (void)
  1092.      Returns the `GtkContainer' type identifier.
  1093.  
  1094.  - Function: void gtk_container_border_width (GtkContainer *CONTAINER,
  1095.           gint BORDER_WIDTH)
  1096.  
  1097.  - Function: void gtk_container_add (GtkContainer *CONTAINER, GtkWidget
  1098.           *WIDGET)
  1099.      Add WIDGET to the CONTAINER.
  1100.  
  1101.  - Function: void gtk_container_remove (GtkContainer *CONTAINER,
  1102.           GtkWidget *WIDGET)
  1103.      Remove WIDGET from CONTAINER.
  1104.  
  1105.  - Function: void gtk_container_disable_resize (GtkContainer *CONTAINER)
  1106.  
  1107.  - Function: void gtk_container_enable_resize (GtkContainer *CONTAINER)
  1108.  
  1109.  - Function: void gtk_container_block_resize (GtkContainer *CONTAINER)
  1110.  
  1111.  - Function: void gtk_container_unblock_resize (GtkContainer *CONTAINER)
  1112.  
  1113.  - Function: gint gtk_container_need_resize (GtkContainer *CONTAINER,
  1114.           GtkWidget *WIDGET)
  1115.  
  1116.  - Function: void gtk_container_check_resize (GtkContainer *CONTAINER,
  1117.           GtkWidget *WIDGET)
  1118.  
  1119.  - Function: void gtk_container_foreach (GtkContainer *CONTAINER,
  1120.           GtkCallback CALLBACK, gpointer CALLBACK_DATA)
  1121.  
  1122.  - Function: void gtk_container_focus (GtkContainer *CONTAINER,
  1123.           GtkDirectionType DIRECTION)
  1124.  
  1125.  - Function: GList* gtk_container_children (GtkContainer CONTAINER)
  1126.  
  1127.  - Function: GtkContainer* GTK_CONTAINER (gpointer OBJ)
  1128.      Cast a generic pointer to `GtkContainer*'. *Note Standard
  1129.      Macros::, for more info.
  1130.  
  1131.  - Function: GtkContainerClass* GTK_CONTAINER_CLASS (gpointer CLASS)
  1132.      Cast a generic pointer to `GtkContainerClass*'. *Note Standard
  1133.      Macros::, for more info.
  1134.  
  1135.  - Function: gint GTK_IS_CONTAINER (gpointer OBJ)
  1136.      Determine if a generic pointer refers to a `GtkContainer' object.
  1137.      *Note Standard Macros::, for more info.
  1138.  
  1139. 
  1140. File: gtk.info,  Node: GtkCTree,  Next: GtkCurve,  Prev: GtkContainer,  Up: Widgets
  1141.  
  1142. The multi-column tree widget
  1143. ============================
  1144.  
  1145. Description
  1146. -----------
  1147.  
  1148.    The GtkCTree widget is a multi-columned list with a designated
  1149. column, the `tree column', to display hierarchically-organized data.
  1150. Each node is either a folder (a branch of the tree) or a leaf. Nodes
  1151. can be (recursively) expanded, collapsed, (un)selected, removed, moved,
  1152. sorted etc.
  1153.  
  1154.    GtkCTree is a descendant of *note GtkCList::.. Therefore, a cell in
  1155. a column other than the tree column can only contain a string, a
  1156. pixmap, both or nothing. A node in the tree column can contain a string
  1157. and up to two pixmaps and masks, indicating the "folder openend" and
  1158. "folder closed" status.
  1159.  
  1160.    Compared to GtkCList, there is no concept of row numbers. Therefore,
  1161. a number of GtkCList methods had to be re-implemented taking `GList
  1162. *node' arguments instead of `gint row'.
  1163.  
  1164. Options
  1165. -------
  1166.  
  1167. Signals
  1168. -------
  1169.  
  1170.  - Signal: void GtkCTree::tree_expand (GtkCTree *CTREE, GList *NODE)
  1171.  
  1172.  - Signal: void GtkCTree::tree_collapse (GtkCTree *CTREE, GList *NODE)
  1173.  
  1174.  - Signal: void GtkCTree::tree_move (GtkCTree *CTREE, GList *NODE,
  1175.           GList *NEW_PARENT, GList *NEW_SIBLING)
  1176.  
  1177.  - Signal: void GtkCTree::tree_select_row (GtkCTree *CTREE, GList *ROW,
  1178.           gint COLUMN)
  1179.  
  1180.  - Signal: void GtkCTree::tree_unselect_row (GtkCTree *CTREE, GList
  1181.           *ROW, gint COLUMN)
  1182.  
  1183. Functions
  1184. ---------
  1185.  
  1186.  - Function: GtkType gtk_ctree_get_type (void)
  1187.      Returns the `GtkCTree' type identifier.
  1188.  
  1189.  - Function: GtkWidget* gtk_ctree_new (gint COLUMNS, gint TREE_COLUMN)
  1190.      Creates a new GtkCTree widget with the given number of columns and
  1191.      the given tree column.
  1192.  
  1193.      On success, a pointer to the newly created widget is returned, and
  1194.      `NULL' otherwise.
  1195.  
  1196.  - Function: GtkWidget* gtk_ctree_new_with_titles (gint COLUMNS, gint
  1197.           TREE_COLUMN, gchar *TITLES[])
  1198.      Creates a new GtkCTree widget with the given number of columns and
  1199.      the given tree column. The column titles are initialized to the
  1200.      strings of the array TITLES.
  1201.  
  1202.      On success, a pointer to the newly created widget is returned, and
  1203.      `NULL' otherwise.
  1204.  
  1205.  - Function: GList* gtk_ctree_insert (GtkCTree *CTREE, GList *PARENT,
  1206.           GList *SIBLING, gchar *TEXT[], guint8 SPACING, GdkPixmap
  1207.           *PIXMAP_CLOSED, GdkPixmap *MASK_CLOSED, GdkPixmap
  1208.           *PIXMAP_OPENED, GdkPixmap *MASK_OPENED, gboolean IS_LEAF,
  1209.           gboolean EXPANDED)
  1210.      Inserts a new node at the given position. If PARENT == NULL, the
  1211.      node is inserted at root level. If SIBLING == NULL, the node is
  1212.      appended to the existing list of siblings. Otherwise, the node is
  1213.      inserted before SIBLING.  If not NULL, the two pixmaps/masks are
  1214.      used to indicate the opened/closed status of the node. SPACING is
  1215.      the number of pixels between pixmap and text.  If IS_LEAF == TRUE,
  1216.      the node cannot have any children.  The initial expanded/collapsed
  1217.      status is given by EXPANDED.
  1218.  
  1219.      On success, the pointer to the newly inserted node is returned,
  1220.      and NULL otherwise.
  1221.  
  1222.  - Function: void gtk_ctree_remove (GtkCTree *CTREE, GList *NODE)
  1223.      Removes the given node and all its children.
  1224.  
  1225.  - Function: void gtk_ctree_clear (GtkCTree *CTREE)
  1226.      Removes all nodes of CTREE.
  1227.  
  1228.  - Function: void gtk_ctree_post_recursive (GtkCTree *CTREE, GList
  1229.           *NODE, GtkCTreeFunc FUNC, gpointer DATA)
  1230.      Apply FUNC to NODE and all its children, traversing CTREE in
  1231.      post-order.
  1232.  
  1233.  - Function: void gtk_ctree_pre_recursive (GtkCTree *CTREE, GList
  1234.           *NODE, GtkCTreeFunc FUNC, gpointer DATA)
  1235.      Apply FUNC to NODE and all its children, traversing CTREE in
  1236.      pre-order.
  1237.  
  1238.  - Function: gboolean gtk_ctree_is_visible (GtkCTree *CTREE, GList
  1239.           *NODE)
  1240.      Returns the visibility status of the given node. A node is said to
  1241.      be visible if in the chain of parent nodes every node is expanded.
  1242.      Or : the node is currently being displayed (but not necessarily
  1243.      inside the viewing area).
  1244.  
  1245.  - Function: GtkCTree* GTK_CTREE (gpointer OBJ)
  1246.      Cast a generic pointer to `GtkCTree*'. *Note Standard Macros::, for
  1247.      more info.
  1248.  
  1249.  - Function: GtkCTreeClass* GTK_CTREE_CLASS (gpointer CLASS)
  1250.      Cast a generic pointer to `GtkCTreeClass*'. *Note Standard
  1251.      Macros::, for more info.
  1252.  
  1253.  - Function: gint GTK_IS_CTREE (gpointer OBJ)
  1254.      Determine if a generic pointer refers to a `GtkCTree' object.
  1255.      *Note Standard Macros::, for more info.
  1256.  
  1257. 
  1258. File: gtk.info,  Node: GtkCurve,  Next: GtkGammaCurve,  Prev: GtkCTree,  Up: Widgets
  1259.  
  1260. The curve widget
  1261. ================
  1262.  
  1263. Description
  1264. -----------
  1265.  
  1266.    Derived from *note GtkDrawingArea::..
  1267.  
  1268. Options
  1269. -------
  1270.  
  1271.  - User Option: type
  1272.         * GTK_CURVE_TYPE_LINEAR
  1273.  
  1274.         * GTK_CURVE_TYPE_SPLINE
  1275.  
  1276.         * GTK_CURVE_TYPE_FREE
  1277.  
  1278. Signals
  1279. -------
  1280.  
  1281. Functions
  1282. ---------
  1283.  
  1284.  - Function: guint gtk_curve_get_type (void)
  1285.      Returns the `GtkCurve' type identifier.
  1286.  
  1287.  - Function: GtkWidget* gtk_curve_new (void)
  1288.      Create a new `GtkCurve' returning the new widget as a pointer to a
  1289.      `GtkWidget' object.
  1290.  
  1291.  - Function: void gtk_curve_reset (GtkCurve *CURVE)
  1292.  
  1293.  - Function: void gtk_curve_set_gamma (GtkCurve *CURVE, gfloat GAMMA)
  1294.  
  1295.  - Function: void gtk_curve_set_range (GtkCurve *CURVE, gfloat MIN_X,
  1296.           gfloat MAX_X, gfloat MIN_Y, gfloat MAX_Y)
  1297.  
  1298.  - Function: void gtk_curve_get_vector (GtkCurve *CURVE, int VECLEN,
  1299.           gfloat VECTOR[])
  1300.  
  1301.  - Function: void gtk_curve_set_vector (GtkCurve *CURVE, int VECLEN,
  1302.           gfloat VECTOR[])
  1303.  
  1304.  - Function: void gtk_curve_set_curve_type (GtkCurve *CURVE,
  1305.           GtkCurveType TYPE)
  1306.  
  1307.  - Function: GtkCurve* GTK_CURVE (gpointer OBJ)
  1308.      Cast a generic pointer to `GtkCurve*'. *Note Standard Macros::, for
  1309.      more info.
  1310.  
  1311.  - Function: GtkCurveClass* GTK_CURVE_CLASS (gpointer CLASS)
  1312.      Cast a generic pointer to `GtkCurveClass*'. *Note Standard
  1313.      Macros::, for more info.
  1314.  
  1315.  - Function: gint GTK_IS_CURVE (gpointer OBJ)
  1316.      Determine if a generic pointer refers to a `GtkCurve' object.
  1317.      *Note Standard Macros::, for more info.
  1318.  
  1319. 
  1320. File: gtk.info,  Node: GtkGammaCurve,  Next: GtkDialog,  Prev: GtkCurve,  Up: Widgets
  1321.  
  1322. The gamma curve widget
  1323. ======================
  1324.  
  1325. Description
  1326. -----------
  1327.  
  1328.    Lets the user edit a gamma curve (a one-to-one mapping usually used
  1329. to adjust the intensity of an image to the physical characteristics of
  1330. the output device).  You can set the minimum and maximum values for
  1331. input and output.  You can set the initial vector as well.  You are
  1332. guaranteed that every input value will have a (not necessarily unique)
  1333. output value specified.  Derived from *note GtkVBox::..  Makes use of
  1334. *note GtkCurve::. to draw the curve.
  1335.  
  1336. Options
  1337. -------
  1338.  
  1339. Signals
  1340. -------
  1341.  
  1342. Functions
  1343. ---------
  1344.  
  1345.  - Function: guint gtk_gamma_curve_get_type (void)
  1346.      Returns the `GtkGamma' type identifier.
  1347.  
  1348.  - Function: GtkWidget* gtk_gamma_curve_new (void)
  1349.      Create a new `GtkGamma' returning the new widget as a pointer to a
  1350.      `GtkWidget' object.
  1351.  
  1352.  - Function: GtkGammaCurve* GTK_GAMMACURVE (gpointer OBJ)
  1353.      Cast a generic pointer to `GtkGammaCurve*'. *Note Standard
  1354.      Macros::, for more info.
  1355.  
  1356.  - Function: GtkGammaCurveClass* GTK_GAMMACURVE_CLASS (gpointer CLASS)
  1357.      Cast a generic pointer to `GtkGammaCurveClass*'. *Note Standard
  1358.      Macros::, for more info.
  1359.  
  1360.  - Function: gint GTK_IS_GAMMACURVE (gpointer OBJ)
  1361.      Determine if a generic pointer refers to a `GtkGammaCurve' object.
  1362.      *Note Standard Macros::, for more info.
  1363.  
  1364. 
  1365. File: gtk.info,  Node: GtkDialog,  Next: GtkDrawingArea,  Prev: GtkGammaCurve,  Up: Widgets
  1366.  
  1367. The dialog widget
  1368. =================
  1369.  
  1370. Description
  1371. -----------
  1372.  
  1373.    The dialog widget is a window (*note GtkWindow::.) that has a
  1374. vertical box (*note GtkVBox::.), a horizontal box (*note GtkHBox::.),
  1375. separated with a horizontal separator (*note GtkHSeparator::.).
  1376.  
  1377. Options
  1378. -------
  1379.  
  1380. Signals
  1381. -------
  1382.  
  1383. Functions
  1384. ---------
  1385.  
  1386.  - Function: guint gtk_dialog_get_type (void)
  1387.      Returns the `GtkDialog' type identifier.
  1388.  
  1389.  - Function: GtkWidget* gtk_dialog_new (void)
  1390.      Create a new `GtkDialog' object and return the new widget as a
  1391.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  1392.  
  1393.  - Function: GtkDialog* GTK_DIALOG (gpointer OBJ)
  1394.      Cast a generic pointer to `GtkDialog*'. *Note Standard Macros::,
  1395.      for more info.
  1396.  
  1397.  - Function: GtkDialogClass* GTK_DIALOG_CLASS (gpointer CLASS)
  1398.      Cast a generic pointer to `GtkDialogClass*'. *Note Standard
  1399.      Macros::, for more info.
  1400.  
  1401.  - Function: gint GTK_IS_DIALOG (gpointer OBJ)
  1402.      Determine if a generic pointer refers to a `GtkDialog' object.
  1403.      *Note Standard Macros::, for more info.
  1404.  
  1405. 
  1406. File: gtk.info,  Node: GtkDrawingArea,  Next: GtkEntry,  Prev: GtkDialog,  Up: Widgets
  1407.  
  1408. The drawing area widget
  1409. =======================
  1410.  
  1411. Description
  1412. -----------
  1413.  
  1414.    A base class for widgets that need a box to draw into.  So far, only
  1415. used by GtkCurve.
  1416.  
  1417. Options
  1418. -------
  1419.  
  1420.  - User Option: width
  1421.  
  1422.  - User Option: height
  1423.  
  1424. Signals
  1425. -------
  1426.  
  1427. Functions
  1428. ---------
  1429.  
  1430.  - Function: guint gtk_drawing_area_get_type (void)
  1431.      Returns the `GtkDrawingArea' type identifier.
  1432.  
  1433.  - Function: GtkWidget* gtk_drawing_area_new (void)
  1434.      Create a new `GtkDrawingArea' object returning the new widget as a
  1435.      pointer to a `GtkWidget' object. `NULL' is returned on failure.
  1436.  
  1437.  - Function: void gtk_drawing_area_size (GtkDrawingArea *DAREA, gint
  1438.           WIDTH, gint HEIGHT)
  1439.      Set the size of the DAREA widget, created previously, to WIDTH and
  1440.      HEIGHT.
  1441.  
  1442.  - Function: GtkDrawingArea* GTK_DRAWING_AREA (gpointer OBJ)
  1443.      Cast a generic pointer to `GtkDrawingArea*'. *Note Standard
  1444.      Macros::, for more info.
  1445.  
  1446.  - Function: GtkDrawingAreaClass* GTK_DRAWING_AREA_CLASS (gpointer
  1447.           CLASS)
  1448.      Cast a generic pointer to `GtkDrawingAreaClass*'. *Note Standard
  1449.      Macros::, for more info.
  1450.  
  1451.  - Function: gint GTK_IS_DRAWING_AREA (gpointer OBJ)
  1452.      Determine if a generic pointer refers to a `GtkDrawingArea'
  1453.      object. *Note Standard Macros::, for more info.
  1454.  
  1455.